/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
module dwt.graphics.image;


private import dwt.dwt;



private import dwt.graphics.color;
private import dwt.graphics.cursor;
private import dwt.graphics.device;
private import dwt.graphics.devicedata;
private import dwt.graphics.drawable;
private import dwt.graphics.font;
private import dwt.graphics.fontdata;
private import dwt.graphics.fontmetrics;
private import dwt.graphics.gc;
private import dwt.graphics.gcdata;
private import dwt.graphics.imagedata;
private import dwt.graphics.imageloader;
private import dwt.graphics.imageloaderevent;
private import dwt.graphics.imageloaderlistener;
private import dwt.graphics.palettedata;
private import dwt.graphics.point;
private import dwt.graphics.rectangle;
private import dwt.graphics.region;
private import dwt.graphics.rgb;
private import dwt.graphics.textlayout;
private import dwt.graphics.textstyle;
private import dwt.internal.win32.os;

private import dwt.internal.compatibility;


private import dwt.util.javatypes;
private import dwt.util.util;
private import dwt.util.vector;
private import dwt.util.hashtable;
private import dwt.util.eventhandler;


/**
 * Instances of this class are graphics which have been prepared
 * for display on a specific device. That is, they are ready
 * to paint using methods such as <code>GC.drawImage()</code>
 * and display on widgets with, for example, <code>Button.setImage()</code>.
 * <p>
 * If loaded from a file format that supports it, an
 * <code>Image</code> may have transparency, meaning that certain
 * pixels are specified as being transparent when drawn. Examples
 * of file formats that support transparency are GIF and PNG.
 * </p><p>
 * There are two primary ways to use <code>Images</code>. 
 * The first is to load a graphic file from disk and create an
 * <code>Image</code> from it. This is done using an <code>Image</code>
 * constructor, for example:
 * <pre>
 *    Image i = new Image(device, "C:\\graphic.bmp");
 * </pre>
 * A graphic file may contain a color table specifying which
 * colors the image was intended to possess. In the above example,
 * these colors will be mapped to the closest available color in
 * DWT. It is possible to get more control over the mapping of
 * colors as the image is being created, using code of the form:
 * <pre>
 *    ImageData data = new ImageData("C:\\graphic.bmp"); 
 *    RGB[] rgbs = data.getRGBs(); 
 *    // At this point, rgbs contains specifications of all
 *    // the colors contained within this image. You may
 *    // allocate as many of these colors as you wish by
 *    // using the Color constructor Color(RGB), then
 *    // create the image:
 *    Image i = new Image(device, data);
 * </pre>
 * <p>
 * Applications which require even greater control over the image
 * loading process should use the support provided in class
 * <code>ImageLoader</code>.
 * </p><p>
 * Application code must explicitely invoke the <code>Image.dispose()</code> 
 * method to release the operating system resources managed by each instance
 * when those instances are no longer required.
 * </p>
 *
 * @see Color
 * @see ImageData
 * @see ImageLoader
 */

public class Image : Drawable {

	/**
	 * specifies whether the receiver is a bitmap or an icon
	 * (one of <code>DWT.BITMAP</code>, <code>DWT.ICON</code>)
	 */
	public int type;
	
	/**
	 * the handle to the OS image resource
	 * (Warning: This field is platform dependent)
	 */
	 // HBITMAP HICON HCURSOR ...
	public HGDIOBJ handle;
	
	/**
	 * the device where this image was created
	 */
	Device device;
	
	/**
	 * specifies the transparent pixel
	 * (Warning: This field is platform dependent)
	 */
	int transparentPixel = -1;
	
	/**
	 * the GC which is drawing on the image
	 * (Warning: This field is platform dependent)
	 */
	GC memGC;
	
	/**
	 * the alpha data for the image
	 * (Warning: This field is platform dependent)
	 */
	byte[] alphaData;
	
	/**
	 * the global alpha value to be used for every pixel
	 * (Warning: This field is platform dependent)
	 */
	int alpha = -1;
	
	/**
	 * the image data used to create this image if it is a
	 * icon. Used only in WinCE
	 * (Warning: This field is platform dependent)
	 */
	ImageData data;
	
	/**
	 * specifies the default scanline padding
	 * (Warning: This field is platform dependent)
	 */
	static int DEFAULT_SCANLINE_PAD = 4;

/**
 * Prevents uninitialized instances from being created outside the package.
 */
this () {
}

/**
 * Constructs an empty instance of this class with the
 * specified width and height. The result may be drawn upon
 * by creating a GC and using any of its drawing operations,
 * as shown in the following example:
 * <pre>
 *    Image i = new Image(device, width, height);
 *    GC gc = new GC(i);
 *    gc.drawRectangle(0, 0, 50, 50);
 *    gc.dispose();
 * </pre>
 * <p>
 * Note: Some platforms may have a limitation on the size
 * of image that can be created (size depends on width, height,
 * and depth). For example, Windows 95, 98, and ME do not allow
 * images larger than 16M.
 * </p>
 *
 * @param device the device on which to create the image
 * @param width the width of the new image
 * @param height the height of the new image
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if device is null and there is no current device</li>
 *    <li>ERROR_INVALID_ARGUMENT - if either the width or height is negative or zero</li>
 * </ul>
 * @exception SWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
public this(Device device, int width, int height) {
	if (device is null) device = Device.getDevice();
	if (device is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NULL_ARGUMENT);
	init(device, width, height);
	
	debug
	{
	if (device.tracking) device.new_Object(this);	
	}
}

/**
 * Constructs a new instance of this class based on the
 * provided image, with an appearance that varies depending
 * on the value of the flag. The possible flag values are:
 * <dl>
 * <dt><b>IMAGE_COPY</b></dt>
 * <dd>the result is an identical copy of srcImage</dd>
 * <dt><b>IMAGE_DISABLE</b></dt>
 * <dd>the result is a copy of srcImage which has a <em>disabled</em> look</dd>
 * <dt><b>IMAGE_GRAY</b></dt>
 * <dd>the result is a copy of srcImage which has a <em>gray scale</em> look</dd>
 * </dl>
 *
 * @param device the device on which to create the image
 * @param srcImage the image to use as the source
 * @param flag the style, either <code>IMAGE_COPY</code>, <code>IMAGE_DISABLE</code> or <code>IMAGE_GRAY</code>
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if device is null and there is no current device</li>
 *    <li>ERROR_NULL_ARGUMENT - if srcImage is null</li>
 *    <li>ERROR_INVALID_ARGUMENT - if the flag is not one of <code>IMAGE_COPY</code>, <code>IMAGE_DISABLE</code> or <code>IMAGE_GRAY</code></li>
 *    <li>ERROR_INVALID_ARGUMENT - if the image has been disposed</li>
 * </ul>
 * @exception SWTException <ul>
 *    <li>ERROR_INVALID_IMAGE - if the image is not a bitmap or an icon, or
 *          is otherwise in an invalid state</li>
 *    <li>ERROR_UNSUPPORTED_DEPTH - if the depth of the Image is not supported</li>
 * </ul>
 * @exception SWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
public this(Device device, Image srcImage, int flag) {
	if (device is null) device = Device.getDevice();
	if (device is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NULL_ARGUMENT);
	this.device = device;
	if (srcImage is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NULL_ARGUMENT);
	if (srcImage.isDisposed()) DWT.error(__FILE__, __LINE__, DWT.ERROR_INVALID_ARGUMENT);
	switch (flag) {
		case DWT.IMAGE_COPY: {
			Rectangle r = srcImage.getBounds();
			this.type = srcImage.type;
			switch (type) {
				case DWT.BITMAP:
					/* Get the HDC for the device */
					HDC hDC = device.internal_new_GC(null);
					
					/* Copy the bitmap */
					HDC hdcSource = OS.CreateCompatibleDC(hDC);
					HDC hdcDest = OS.CreateCompatibleDC(hDC);
					HGDIOBJ hOldSrc = OS.SelectObject(hdcSource, srcImage.handle);
					handle = OS.CreateCompatibleBitmap(hdcSource, r.width, r.height);
					if (handle is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NO_HANDLES);
					HGDIOBJ hOldDest = OS.SelectObject(hdcDest, handle);
					OS.BitBlt(hdcDest, 0, 0, r.width, r.height, hdcSource, 0, 0, OS.SRCCOPY);
					OS.SelectObject(hdcSource, hOldSrc);
					OS.SelectObject(hdcDest, hOldDest);
					OS.DeleteDC(hdcSource);
					OS.DeleteDC(hdcDest);

					/* Release the HDC for the device */
					device.internal_dispose_GC(hDC, null);

					transparentPixel = srcImage.transparentPixel;
					alpha = srcImage.alpha;
					if (srcImage.alphaData !is null) {
						alphaData = new byte[srcImage.alphaData.length];
						System.arraycopy(srcImage.alphaData, 0, alphaData, 0, alphaData.length);
					}
					break;
				case DWT.ICON:
					version(WinCE) {
						init(device, srcImage.data);
					} else {
						handle = OS.CopyImage(srcImage.handle, OS.IMAGE_ICON, r.width, r.height, 0);
						if (handle is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NO_HANDLES);
					}
					break;
				default:
					DWT.error(__FILE__, __LINE__, DWT.ERROR_UNSUPPORTED_FORMAT);
			}
			debug
			{
			if (device.tracking) device.new_Object(this);	
			}
			return;
		}
		case DWT.IMAGE_DISABLE: {
			Rectangle r = srcImage.getBounds();
			this.type = srcImage.type;
//			byte[] rgbBwBitmapInfo = {
//				40,0,0,0, /* biSize */
//				cast(byte)(r.width & 0xFF), /* biWidth */
//				cast(byte)((r.width & 0xFF00) >> 8),
//				cast(byte)((r.width & 0xFF0000) >> 16),
//				cast(byte)((r.width & 0xFF000000) >> 24),
//				cast(byte)(r.height & 0xFF), /* biHeight */
//				cast(byte)((r.height & 0xFF00) >> 8),
//				cast(byte)((r.height & 0xFF0000) >> 16),
//				cast(byte)((r.height & 0xFF000000) >> 24),
//				1,0, /* biPlanes */
//				1,0, /* biBitCount */
//				0,0,0,0, /* biCompression */
//				0,0,0,0, /* biSizeImage */
//				0,0,0,0, /* biXPelsPerMeter */
//				0,0,0,0, /* biYPelsPerMeter */
//				0,0,0,0, /* biClrUsed */
//				0,0,0,0, /* biClrImportant */
//				0,0,0,0, /* First color: black */
//				cast(byte)0xFF,cast(byte)0xFF,cast(byte)0xFF,0 /* Second color: white */
//			};
			byte[] rgbBwBitmapInfo;
			rgbBwBitmapInfo ~= 40; rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0;  /* biSize */
			rgbBwBitmapInfo ~= cast(byte)(r.width & 0xFF);  /* biWidth */
			rgbBwBitmapInfo ~= cast(byte)((r.width & 0xFF00) >> 8);
			rgbBwBitmapInfo ~= cast(byte)((r.width & 0xFF0000) >> 16);
			rgbBwBitmapInfo ~= cast(byte)((r.width & 0xFF000000) >> 24);
			rgbBwBitmapInfo ~= cast(byte)(r.height & 0xFF);  /* biHeight */
			rgbBwBitmapInfo ~= cast(byte)((r.height & 0xFF00) >> 8);
			rgbBwBitmapInfo ~= cast(byte)((r.height & 0xFF0000) >> 16);
			rgbBwBitmapInfo ~= cast(byte)((r.height & 0xFF000000) >> 24);
			rgbBwBitmapInfo ~= 1; rgbBwBitmapInfo ~= 0;  /* biPlanes */
			rgbBwBitmapInfo ~= 1; rgbBwBitmapInfo ~= 0;   /* biBitCount */
			rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0;   /* biCompression */
			rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0;   /* biSizeImage */
			rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0;   /* biXPelsPerMeter */
			rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0;   /* biYPelsPerMeter */
			rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0;   /* biClrUsed */
			rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0;   /* biClrImportant */
			rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0; rgbBwBitmapInfo ~= 0;   /* First color: black	*/
			rgbBwBitmapInfo ~= cast(byte)0xFF; rgbBwBitmapInfo ~= cast(byte)0xFF; 
			rgbBwBitmapInfo ~= cast(byte)0xFF; rgbBwBitmapInfo ~= 0; /* Second color: white */

			/* Get the HDC for the device */
			HDC hDC = device.internal_new_GC(null);

			/* Source DC */
			HDC hdcSource = OS.CreateCompatibleDC(hDC);
			if (hdcSource is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NO_HANDLES);
			/* Monochrome (Intermediate) DC */
			HDC bwDC = OS.CreateCompatibleDC(hdcSource);
			if (bwDC is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NO_HANDLES);
			/* Destination DC */
			HDC hdcBmp = OS.CreateCompatibleDC(hDC);
			if (hdcBmp is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NO_HANDLES);
			/* Monochrome (Intermediate) DIB section */
			int[] pbitsBW = new int[1];
			HBITMAP hbmBW = OS.CreateDIBSection(bwDC, cast(BITMAPINFO*)rgbBwBitmapInfo, OS.DIB_RGB_COLORS, cast(void**)pbitsBW.ptr, null, 0);
			if (hbmBW is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NO_HANDLES);
			switch (type) {
				case DWT.BITMAP:
					/* Attach the bitmap to the source DC */
					HGDIOBJ hOldSrc = OS.SelectObject(hdcSource, srcImage.handle);
					/* Create the destination bitmap */
					handle = OS.CreateCompatibleBitmap(hDC, r.width, r.height);
					if (handle is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NO_HANDLES);
					/* Attach the DIB section and the new bitmap to the DCs */
					HGDIOBJ hOldBw = OS.SelectObject(bwDC, hbmBW);
					HBITMAP hOldBmp = OS.SelectObject(hdcBmp, handle);
					/* BitBlt the bitmap into the monochrome DIB section */
					OS.BitBlt(bwDC, 0, 0, r.width, r.height, hdcSource, 0, 0, OS.SRCCOPY);
					/* Paint the destination rectangle in gray */
					RECT rect;
					rect.left = 0;
					rect.top = 0;
					rect.right = r.width;
					rect.bottom = r.height;
					OS.FillRect(hdcBmp, &rect, OS.GetSysColorBrush(OS.COLOR_3DFACE));
					/*
					 * BitBlt the black bits in the monochrome bitmap into
					 * COLOR_3DHILIGHT bits in the destination DC.
					 * The magic ROP comes from Charles Petzold's book
					 */
					HBRUSH hb = OS.CreateSolidBrush(OS.GetSysColor(OS.COLOR_3DHILIGHT));
					HBRUSH oldBrush = OS.SelectObject(hdcBmp, hb);
					OS.BitBlt(hdcBmp, 1, 1, r.width, r.height, bwDC, 0, 0, 0xB8074A);
					/*
					 * BitBlt the black bits in the monochrome bitmap into 
					 * COLOR_3DSHADOW bits in the destination DC.
					 */
					hb = OS.CreateSolidBrush(OS.GetSysColor(OS.COLOR_3DSHADOW));
					OS.DeleteObject(OS.SelectObject(hdcBmp, hb));
					OS.BitBlt(hdcBmp, 0, 0, r.width, r.height, bwDC, 0, 0, 0xB8074A);
					OS.DeleteObject(OS.SelectObject(hdcBmp, oldBrush));
					/* Free resources */
					OS.SelectObject(hdcSource, hOldSrc);
					OS.SelectObject(hdcBmp, hOldBmp);
					OS.SelectObject(bwDC, hOldBw);
					OS.DeleteDC(hdcSource);
					OS.DeleteDC(bwDC);
					OS.DeleteDC(hdcBmp);
					OS.DeleteObject(hbmBW);
					
					/* Release the HDC for the device */
					device.internal_dispose_GC(hDC, null);
					break;
				case DWT.ICON:
					HGDIOBJ hOldBmp, _hdcBmp, oldBrush;
					HGDIOBJ hOldSrc, hOldBw, hb;
					RECT rect;
					/* Get icon information */
					ICONINFO* iconInfo = new ICONINFO();
					version(WinCE) {
						GetIconInfo(srcImage, iconInfo);
					} else {
						if (!OS.GetIconInfo(srcImage.handle, iconInfo))
							DWT.error(__FILE__, __LINE__, DWT.ERROR_INVALID_IMAGE);
					}
					HDC hdcMask = OS.CreateCompatibleDC(hDC);
					/* Create the destination bitmaps */
					if (iconInfo.hbmColor is null)
						hOldSrc = OS.SelectObject(hdcSource, iconInfo.hbmMask);
					else
						hOldSrc = OS.SelectObject(hdcSource, iconInfo.hbmColor);
					HBITMAP newHbmp = OS.CreateCompatibleBitmap(hdcSource, r.width, r.height);
					if (newHbmp is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NO_HANDLES);
					HBITMAP newHmask = OS.CreateBitmap(r.width, r.height, 1, 1, null);
					if (newHmask is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NO_HANDLES);
					/* BitBlt the source mask into the destination mask */
					HBITMAP hOldMask = OS.SelectObject(hdcMask, newHmask);
					if (iconInfo.hbmColor !is null)
						OS.SelectObject(hdcSource, iconInfo.hbmMask);
					OS.SelectObject(hdcSource, iconInfo.hbmMask);
					OS.BitBlt(hdcMask, 0, 0, r.width, r.height, hdcSource, 0, 0, OS.SRCCOPY);
					/* Attach the monochrome DIB section and the destination bitmap to the DCs */
					hOldBw = OS.SelectObject(bwDC, hbmBW);
					/* BitBlt the bitmap into the monochrome DIB section */
					if (iconInfo.hbmColor is null) {
						OS.SelectObject(hdcSource, iconInfo.hbmMask);
						OS.BitBlt(bwDC, 0, 0, r.width, r.height, hdcSource, 0, r.height, OS.SRCCOPY);
					} else {
						OS.SelectObject(hdcSource, iconInfo.hbmColor);
						OS.BitBlt(bwDC, 0, 0, r.width, r.height, hdcSource, 0, 0, OS.SRCCOPY);
					}
					/* Paint the destination rectangle in grey */
					rect.left = 0;
					rect.top = 0;
					rect.right = r.width;
					rect.bottom = r.height;
					hOldBmp = OS.SelectObject(_hdcBmp, newHbmp);
					OS.FillRect(_hdcBmp, &rect, OS.GetSysColorBrush(OS.COLOR_3DFACE));
					/*
					 * BitBlt the black bits in the monochrome bitmap into
					 * COLOR_3DHILIGHT bits in the destination DC.
					 * The magic ROP comes from Charles Petzold's book
					 */
					hb = OS.CreateSolidBrush(OS.GetSysColor(OS.COLOR_3DSHADOW));
					oldBrush = OS.SelectObject(_hdcBmp, hb);
					OS.BitBlt(_hdcBmp, 0, 0, r.width, r.height, bwDC, 0, 0, 0xB8074A);
					/* Invert mask into hdcBw */
					OS.BitBlt(bwDC, 0, 0, r.width, r.height, hdcMask, 0, 0, OS.NOTSRCCOPY);
					/* Select black brush into destination */
					hb = OS.CreateSolidBrush(0);
					OS.DeleteObject(OS.SelectObject(_hdcBmp, hb));
					/*
					 * Copy black bits from monochrome bitmap into black bits in the
					 * destination DC.
					 */
					OS.BitBlt(_hdcBmp, 0, 0, r.width, r.height, bwDC, 0, 0, 0xB8074A);
					OS.DeleteObject(OS.SelectObject(_hdcBmp, oldBrush));
					/* Free resources */
					OS.SelectObject(hdcSource, hOldSrc);
					OS.DeleteDC(hdcSource);
					OS.SelectObject(bwDC, hOldBw);
					OS.DeleteDC(bwDC);
					OS.SelectObject(_hdcBmp, hOldBmp);
					OS.DeleteDC(_hdcBmp);
					OS.SelectObject(hdcMask, hOldMask);
					OS.DeleteDC(hdcMask);
					OS.DeleteObject(hbmBW);
					
					/* Release the HDC for the device */
					device.internal_dispose_GC(hDC, null);
			
					/* Create the new iconinfo */
					ICONINFO* newIconInfo = new ICONINFO();
					newIconInfo.fIcon = iconInfo.fIcon;
					newIconInfo.hbmMask = newHmask;
					newIconInfo.hbmColor = newHbmp;
					/* Create the new icon */
					handle = OS.CreateIconIndirect(newIconInfo);
					if (handle is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NO_HANDLES);
					/* Free bitmaps */
					OS.DeleteObject(newHbmp);
					OS.DeleteObject(newHmask);
					if (iconInfo.hbmColor !is null)
						OS.DeleteObject(iconInfo.hbmColor);
					OS.DeleteObject(iconInfo.hbmMask);
					break;
				default:
					DWT.error(__FILE__, __LINE__, DWT.ERROR_UNSUPPORTED_FORMAT);
			}
			debug
			{
			if (device.tracking) device.new_Object(this);	
			}
			return;
		}
		case DWT.IMAGE_GRAY: {
			Rectangle r = srcImage.getBounds();
			ImageData data = srcImage.getImageData();
			PaletteData palette = data.palette;
			ImageData newData = data;
			if (!palette.isDirect) {
				/* Convert the palette entries to gray. */
				DWTRGB [] rgbs = palette.getRGBs();
				for (int i=0; i<rgbs.length; i++) {
					if (data.transparentPixel != i) {
						DWTRGB color = rgbs [i];
						int red = color.red;
						int green = color.green;
						int blue = color.blue;
						int intensity = (red+red+green+green+green+green+green+blue) >> 3;
						color.red = color.green = color.blue = intensity;
					}
				}
				newData.palette = new PaletteData(rgbs);
			} else {
				/* Create a 8 bit depth image data with a gray palette. */
				DWTRGB[] rgbs = new DWTRGB[256];
				for (int i=0; i<rgbs.length; i++) {
					rgbs[i] = new DWTRGB(i, i, i);
				}
				newData = new ImageData(r.width, r.height, 8, new PaletteData(rgbs));
				newData.maskData = data.maskData;
				newData.maskPad = data.maskPad;

				/* Convert the pixels. */
				int[] scanline = new int[r.width];
				int redMask = palette.redMask;
				int greenMask = palette.greenMask;
				int blueMask = palette.blueMask;
				int redShift = palette.redShift;
				int greenShift = palette.greenShift;
				int blueShift = palette.blueShift;
				for (int y=0; y<r.height; y++) {
					int offset = y * newData.bytesPerLine;
					data.getPixels(0, y, r.width, scanline, 0);
					for (int x=0; x<r.width; x++) {
						int pixel = scanline[x];
						int red = pixel & redMask;
						red = (redShift < 0) ? red >>> -redShift : red << redShift;
						int green = pixel & greenMask;
						green = (greenShift < 0) ? green >>> -greenShift : green << greenShift;
						int blue = pixel & blueMask;
						blue = (blueShift < 0) ? blue >>> -blueShift : blue << blueShift;
						newData.data[offset++] =
							cast(byte)((red+red+green+green+green+green+green+blue) >> 3);
					}
				}
			}
			init (device, newData);
			debug
			{
			if (device.tracking) device.new_Object(this);	
			}
			return;
		}
		default:
			DWT.error(__FILE__, __LINE__, DWT.ERROR_INVALID_ARGUMENT);
	}
}

/**
 * Constructs an empty instance of this class with the
 * width and height of the specified rectangle. The result
 * may be drawn upon by creating a GC and using any of its
 * drawing operations, as shown in the following example:
 * <pre>
 *    Image i = new Image(device, boundsRectangle);
 *    GC gc = new GC(i);
 *    gc.drawRectangle(0, 0, 50, 50);
 *    gc.dispose();
 * </pre>
 * <p>
 * Note: Some platforms may have a limitation on the size
 * of image that can be created (size depends on width, height,
 * and depth). For example, Windows 95, 98, and ME do not allow
 * images larger than 16M.
 * </p>
 *
 * @param device the device on which to create the image
 * @param bounds a rectangle specifying the image's width and height (must not be null)
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if device is null and there is no current device</li>
 *    <li>ERROR_NULL_ARGUMENT - if the bounds rectangle is null</li>
 *    <li>ERROR_INVALID_ARGUMENT - if either the rectangle's width or height is negative</li>
 * </ul>
 * @exception SWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
public this(Device device, Rectangle bounds) {
	if (device is null) device = Device.getDevice();
	if (device is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NULL_ARGUMENT);
	if (bounds is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NULL_ARGUMENT);
	init(device, bounds.width, bounds.height);
	debug
	{
	if (device.tracking) device.new_Object(this);	
	}
}

/**
 * Constructs an instance of this class from the given
 * <code>ImageData</code>.
 *
 * @param device the device on which to create the image
 * @param data the image data to create the image from (must not be null)
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if device is null and there is no current device</li>
 *    <li>ERROR_NULL_ARGUMENT - if the image data is null</li>
 * </ul>
 * @exception SWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 * @exception SWTException <ul>
 *    <li>ERROR_UNSUPPORTED_DEPTH - if the depth of the ImageData is not supported</li>
 * </ul>
 */
public this(Device device, ImageData data) {
	if (device is null) device = Device.getDevice();
	if (device is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NULL_ARGUMENT);
	init(device, data);
	debug
	{
	if (device.tracking) device.new_Object(this);	
	}
}

/**
 * Constructs an instance of this class, whose type is 
 * <code>DWT.ICON</code>, from the two given <code>ImageData</code>
 * objects. The two images must be the same size, and the mask image
 * must have a color depth of 1. Pixel transparency in either image
 * will be ignored. If either image is an icon to begin with, an
 * exception is thrown.
 * <p>
 * The mask image should contain white wherever the icon is to be visible,
 * and black wherever the icon is to be transparent. In addition,
 * the source image should contain black wherever the icon is to be
 * transparent.
 * </p>
 *
 * @param device the device on which to create the icon
 * @param source the color data for the icon
 * @param mask the mask data for the icon
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if device is null and there is no current device</li>
 *    <li>ERROR_NULL_ARGUMENT - if either the source or mask is null </li>
 *    <li>ERROR_INVALID_ARGUMENT - if source and mask are different sizes or
 *          if the mask is not monochrome, or if either the source or mask
 *          is already an icon</li>
 * </ul>
 * @exception SWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
public this(Device device, ImageData source, ImageData mask) {
	if (device is null) device = Device.getDevice();
	if (device is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NULL_ARGUMENT);
	if (source is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NULL_ARGUMENT);
	if (mask is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NULL_ARGUMENT);
	if (source.width != mask.width || source.height != mask.height) {
		DWT.error(__FILE__, __LINE__, DWT.ERROR_INVALID_ARGUMENT);
	}
	if (mask.depth != 1) {
		/*
		 * Feature in Windows. 1-bit DIB sections are buggy on Win98, so we
		 * create 4-bit DIBs when given a 1-bit ImageData. In order to allow
		 * users to draw on the masks, we must also support 4-bit masks in
		 * icon creation by converting them into 1-bit masks.
		 */
		if (mask.depth != 4) DWT.error(__FILE__, __LINE__, DWT.ERROR_INVALID_ARGUMENT);
		DWTRGB[] RGBArr;
		RGBArr ~= new DWTRGB(0, 0, 0);
		RGBArr ~= new DWTRGB(255,255,255);
		PaletteData palette = new PaletteData(RGBArr);
		ImageData tempMask = new ImageData(mask.width, mask.height, 1, palette);
		/* Find index of black in mask palette */
		DWTRGB[] rgbs = mask.getRGBs();
		int blackIndex = 0;
		while (blackIndex < rgbs.length) {
			if (rgbs[blackIndex].equals(palette.colors[0])) break;
			blackIndex++;
		}
		if (blackIndex == rgbs.length) DWT.error(__FILE__, __LINE__, DWT.ERROR_INVALID_ARGUMENT);
		int[] pixels = new int[mask.width];
		for (int y = 0; y < mask.height; y++) {
			mask.getPixels(0, y, mask.width, pixels, 0);
			for (int i = 0; i < pixels.length; i++) {
				if (pixels[i] == blackIndex) {
					pixels[i] = 0;
				} else {
					pixels[i] = 1;
				}
			}
			tempMask.setPixels(0, y, mask.width, pixels, 0);
		}
		mask = tempMask;
	}
	init4(device, this, source, mask);
	debug
	{
	if (device.tracking) device.new_Object(this);	
	}
}

/**
 * Constructs an instance of this class by loading its representation
 * from the specified input stream. Throws an error if an error
 * occurs while loading the image, or if the result is an image
 * of an unsupported type.
 * <p>
 * This constructor is provided for convenience when loading a single
 * image only. If the stream contains multiple images, only the first
 * one will be loaded. To load multiple images, use 
 * <code>ImageLoader.load()</code>.
 * </p><p>
 * This constructor may be used to load a resource as follows:
 * </p>
 * <pre>
 *     new Image(device, clazz.getResourceAsStream("file.gif"));
 * </pre>
 *
 * @param device the device on which to create the image
 * @param stream the input stream to load the image from
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if device is null and there is no current device</li>
 *    <li>ERROR_NULL_ARGUMENT - if the stream is null</li>
 * </ul>
 * @exception SWTException <ul>
 *    <li>ERROR_INVALID_IMAGE - if the image file contains invalid data </li>
 *    <li>ERROR_IO - if an IO error occurs while reading data</li>
 *    <li>ERROR_UNSUPPORTED_DEPTH - if the InputStream describes an image with an unsupported depth</li>
 * </ul>
 * @exception SWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
public this (Device device, InputStream stream) {
	if (device is null) device = Device.getDevice();
	if (device is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NULL_ARGUMENT);
	init(device, new ImageData(stream));
	debug
	{
	if (device.tracking) device.new_Object(this);	
	}
}

/**
 * Constructs an instance of this class by loading its representation
 * from the file with the specified name. Throws an error if an error
 * occurs while loading the image, or if the result is an image
 * of an unsupported type.
 * <p>
 * This constructor is provided for convenience when loading
 * a single image only. If the specified file contains
 * multiple images, only the first one will be used.
 *
 * @param device the device on which to create the image
 * @param filename the name of the file to load the image from
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if device is null and there is no current device</li>
 *    <li>ERROR_NULL_ARGUMENT - if the file name is null</li>
 * </ul>
 * @exception SWTException <ul>
 *    <li>ERROR_INVALID_IMAGE - if the image file contains invalid data </li>
 *    <li>ERROR_IO - if an IO error occurs while reading data</li>
 *    <li>ERROR_UNSUPPORTED_DEPTH - if the image file has an unsupported depth</li>
 * </ul>
 * @exception SWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
public this (Device device, char[] filename) {
	if (device is null) device = Device.getDevice();
	if (device is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NULL_ARGUMENT);
	init(device, new ImageData(filename));
	debug
	{
	if (device.tracking) device.new_Object(this);	
	}
}

/** 
 * Create a DIB from a DDB without using GetDIBits. Note that 
 * the DDB should not be selected into a HDC.
 */
HBITMAP createDIBFromDDB(HDC hDC, HBITMAP hBitmap, int width, int height) {
	
	/* Determine the DDB depth */
	int bits = OS.GetDeviceCaps (hDC, OS.BITSPIXEL);
	int planes = OS.GetDeviceCaps (hDC, OS.PLANES);
	int depth = bits * planes;
	
	/* Determine the DIB palette */
	boolean isDirect = depth > 8;
	DWTRGB[] rgbs = null;
	if (!isDirect) {
		int numColors = 1 << depth;
		PALETTEENTRY[] logPalette = new PALETTEENTRY[numColors];
		OS.GetPaletteEntries(device.hPalette, 0, numColors, logPalette.ptr);
		rgbs = new DWTRGB[numColors];
		for (int i = 0; i < numColors; i++) {
			rgbs[i] = new DWTRGB(logPalette[i].peRed & 0xFF, logPalette[i].peGreen & 0xFF, logPalette[i].peBlue & 0xFF);
		}
	}
	
	boolean useBitfields = OS.IsWinCE && (depth == 16 || depth == 32);
	BITMAPINFOHEADER* bmiHeader = new BITMAPINFOHEADER();
	bmiHeader.biSize = BITMAPINFOHEADER.sizeof;
	bmiHeader.biWidth = width;
	bmiHeader.biHeight = -height;
	bmiHeader.biPlanes = 1;
	bmiHeader.biBitCount = cast(WORD)depth;
	if (useBitfields) bmiHeader.biCompression = OS.BI_BITFIELDS;
	else bmiHeader.biCompression = OS.BI_RGB;
	byte[] bmi;
	if (isDirect) bmi = new byte[BITMAPINFOHEADER.sizeof + (useBitfields ? 12 : 0)];
	else  bmi = new byte[BITMAPINFOHEADER.sizeof + rgbs.length * 4];
	OS.MoveMemory(bmi.ptr, bmiHeader, BITMAPINFOHEADER.sizeof);

	/* Set the rgb colors into the bitmap info */
	int offset = BITMAPINFOHEADER.sizeof;
	if (isDirect) {
		if (useBitfields) {
			int redMask = 0;
			int greenMask = 0;
			int blueMask = 0;
			switch (depth) {
				case 16:
					redMask = 0x7C00;
					greenMask = 0x3E0;
					blueMask = 0x1F;
					/* little endian */
					bmi[offset] = cast(byte)((redMask & 0xFF) >> 0);
					bmi[offset + 1] = cast(byte)((redMask & 0xFF00) >> 8);
					bmi[offset + 2] = cast(byte)((redMask & 0xFF0000) >> 16);
					bmi[offset + 3] = cast(byte)((redMask & 0xFF000000) >> 24);
					bmi[offset + 4] = cast(byte)((greenMask & 0xFF) >> 0);
					bmi[offset + 5] = cast(byte)((greenMask & 0xFF00) >> 8);
					bmi[offset + 6] = cast(byte)((greenMask & 0xFF0000) >> 16);
					bmi[offset + 7] = cast(byte)((greenMask & 0xFF000000) >> 24);
					bmi[offset + 8] = cast(byte)((blueMask & 0xFF) >> 0);
					bmi[offset + 9] = cast(byte)((blueMask & 0xFF00) >> 8);
					bmi[offset + 10] = cast(byte)((blueMask & 0xFF0000) >> 16);
					bmi[offset + 11] = cast(byte)((blueMask & 0xFF000000) >> 24);
					break;
				case 32: 
					redMask = 0xFF00;
					greenMask = 0xFF0000;
					blueMask = 0xFF000000;
					/* big endian */
					bmi[offset] = cast(byte)((redMask & 0xFF000000) >> 24);
					bmi[offset + 1] = cast(byte)((redMask & 0xFF0000) >> 16);
					bmi[offset + 2] = cast(byte)((redMask & 0xFF00) >> 8);
					bmi[offset + 3] = cast(byte)((redMask & 0xFF) >> 0);
					bmi[offset + 4] = cast(byte)((greenMask & 0xFF000000) >> 24);
					bmi[offset + 5] = cast(byte)((greenMask & 0xFF0000) >> 16);
					bmi[offset + 6] = cast(byte)((greenMask & 0xFF00) >> 8);
					bmi[offset + 7] = cast(byte)((greenMask & 0xFF) >> 0);
					bmi[offset + 8] = cast(byte)((blueMask & 0xFF000000) >> 24);
					bmi[offset + 9] = cast(byte)((blueMask & 0xFF0000) >> 16);
					bmi[offset + 10] = cast(byte)((blueMask & 0xFF00) >> 8);
					bmi[offset + 11] = cast(byte)((blueMask & 0xFF) >> 0);
					break;
				default:
					DWT.error(__FILE__, __LINE__, DWT.ERROR_UNSUPPORTED_DEPTH);
			}
		}
	} else {
		for (int j = 0; j < rgbs.length; j++) {
			bmi[offset] = cast(byte)rgbs[j].blue;
			bmi[offset + 1] = cast(byte)rgbs[j].green;
			bmi[offset + 2] = cast(byte)rgbs[j].red;
			bmi[offset + 3] = 0;
			offset += 4;
		}
	}
	int[] pBits = new int[1];
	HBITMAP hDib = OS.CreateDIBSection(null, cast(BITMAPINFO*)bmi, cast(uint) OS.DIB_RGB_COLORS, cast(void**)pBits.ptr, null, 0);
	if (hDib is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NO_HANDLES);
	
	/* Bitblt DDB into DIB */	
	HDC hdcSource = OS.CreateCompatibleDC(hDC);
	HDC hdcDest = OS.CreateCompatibleDC(hDC);
	HBITMAP hOldSrc = OS.SelectObject(hdcSource, hBitmap);
	HBITMAP hOldDest = OS.SelectObject(hdcDest, hDib);
	OS.BitBlt(hdcDest, 0, 0, width, height, hdcSource, 0, 0, OS.SRCCOPY);
	OS.SelectObject(hdcSource, hOldSrc);
	OS.SelectObject(hdcDest, hOldDest);
	OS.DeleteDC(hdcSource);
	OS.DeleteDC(hdcDest);
	
	return hDib;
}

/**
 * Disposes of the operating system resources associated with
 * the image. Applications must dispose of all images which
 * they allocate.
 */
public void dispose () {
	if (handle is null) return;
	if (device.isDisposed()) return;
	if (memGC !is null) memGC.dispose();
	if (type == DWT.ICON) {
		version(WinCE) { data = null; }
		OS.DestroyIcon (handle);
	} else {
		OS.DeleteObject (handle);
	}
	handle = null;
	memGC = null;
	debug
	{
	if (device.tracking) device.dispose_Object(this);
	}
	device = null;
}

/**
 * Compares the argument to the receiver, and returns true
 * if they represent the <em>same</em> object using a class
 * specific comparison.
 *
 * @param object the object to compare with this object
 * @return <code>true</code> if the object is the same as this object and <code>false</code> otherwise
 *
 * @see #hashCode
 */
public boolean equals (Object object) {
	if (object is this) return true;
	if (!(cast(Image)object)) return false;
	Image image = cast(Image)object;
	return (device is image.device) && handle is image.handle;
}

/**
 * Returns the color to which to map the transparent pixel, or null if
 * the receiver has no transparent pixel.
 * <p>
 * There are certain uses of Images that do not support transparency
 * (for example, setting an image into a button or label). In these cases,
 * it may be desired to simulate transparency by using the background
 * color of the widget to paint the transparent pixels of the image.
 * Use this method to check which color will be used in these cases
 * in place of transparency. This value may be set with setBackground().
 * <p>
 *
 * @return the background color of the image, or null if there is no transparency in the image
 *
 * @exception SWTException <ul>
 *    <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed</li>
 * </ul>
 */
public Color getBackground() {
	if (isDisposed()) DWT.error(__FILE__, __LINE__, DWT.ERROR_GRAPHIC_DISPOSED);
	if (transparentPixel == -1) return null;

	/* Get the HDC for the device */
	HDC hDC = device.internal_new_GC(null);
	
	/* Compute the background color */
	BITMAP* bm = new BITMAP();		
	OS.GetObject(handle, BITMAP.sizeof, bm);
	HDC hdcMem = OS.CreateCompatibleDC(hDC);
	HGDIOBJ hOldObject = OS.SelectObject(hdcMem, handle);
	int red = 0, green = 0, blue = 0;
	if (bm.bmBitsPixel <= 8)  {
		version(WinCE) {
			byte[] pBits = new byte[1];
			OS.MoveMemory(pBits, bm.bmBits, 1);
			byte oldValue = pBits[0];			
			int mask = (0xFF << (8 - bm.bmBitsPixel)) & 0x00FF;
			pBits[0] = cast(byte)((transparentPixel << (8 - bm.bmBitsPixel)) | (pBits[0] & ~mask));
			OS.MoveMemory(bm.bmBits, pBits, 1);
			int color = OS.GetPixel(hdcMem, 0, 0);
       		pBits[0] = oldValue;
       		OS.MoveMemory(bm.bmBits, pBits, 1);				
			blue = (color & 0xFF0000) >> 16;
			green = (color & 0xFF00) >> 8;
			red = color & 0xFF;
		} else {
			byte[] color = new byte[4];
			OS.GetDIBColorTable(hdcMem, transparentPixel, 1, cast(RGBQUAD*)color);
			blue = color[0] & 0xFF;
			green = color[1] & 0xFF;
			red = color[2] & 0xFF;
		}
	} else {
		switch (bm.bmBitsPixel) {
			case 16:
				blue = (transparentPixel & 0x1F) << 3;
				green = (transparentPixel & 0x3E0) >> 2;
				red = (transparentPixel & 0x7C00) >> 7;
				break;
			case 24:
				blue = (transparentPixel & 0xFF0000) >> 16;
				green = (transparentPixel & 0xFF00) >> 8;
				red = transparentPixel & 0xFF;
				break;
			case 32:
				blue = (transparentPixel & 0xFF000000) >>> 24;
				green = (transparentPixel & 0xFF0000) >> 16;
				red = (transparentPixel & 0xFF00) >> 8;
				break;
			default:
				return null;
		}
	}
	OS.SelectObject(hdcMem, hOldObject);
	OS.DeleteDC(hdcMem);
	
	/* Release the HDC for the device */
	device.internal_dispose_GC(hDC, null);
	return Color.win32_new(device, 0x02000000 | (blue << 16) | (green << 8) | red);
}

/**
 * Returns the bounds of the receiver. The rectangle will always
 * have x and y values of 0, and the width and height of the
 * image.
 *
 * @return a rectangle specifying the image's bounds
 *
 * @exception SWTException <ul>
 *    <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_INVALID_IMAGE - if the image is not a bitmap or an icon</li>
 * </ul>
 */
public Rectangle getBounds() {
	if (isDisposed()) DWT.error(__FILE__, __LINE__, DWT.ERROR_GRAPHIC_DISPOSED);
	switch (type) {
		case DWT.BITMAP:
			BITMAP* bm = new BITMAP();
			OS.GetObject(handle, BITMAP.sizeof, bm);
			return new Rectangle(0, 0, bm.bmWidth, bm.bmHeight);
		case DWT.ICON:
			BITMAP* bm;
			version(WinCE) {
				return new Rectangle(0, 0, data.width, data.height);
			} else {
				ICONINFO* info = new ICONINFO();
				OS.GetIconInfo(handle, info);
				HBITMAP hBitmap = info.hbmColor;
				if (hBitmap is null) hBitmap = info.hbmMask;
				bm = new BITMAP();
				OS.GetObject(hBitmap, BITMAP.sizeof, bm);
				if (hBitmap is info.hbmMask) bm.bmHeight /= 2;
				if (info.hbmColor !is null) OS.DeleteObject(info.hbmColor);
				if (info.hbmMask !is null) OS.DeleteObject(info.hbmMask);
				return new Rectangle(0, 0, bm.bmWidth, bm.bmHeight);
			}
		default:
			DWT.error(__FILE__, __LINE__, DWT.ERROR_UNSUPPORTED_FORMAT);
			return null;
	}
	return null;
}

/**
 * Returns an <code>ImageData</code> based on the receiver
 * Modifications made to this <code>ImageData</code> will not
 * affect the Image.
 *
 * @return an <code>ImageData</code> containing the image's data and attributes
 *
 * @exception SWTException <ul>
 *    <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_INVALID_IMAGE - if the image is not a bitmap or an icon</li>
 * </ul>
 *
 * @see ImageData
 */
public ImageData getImageData() {
	if (isDisposed()) {
		DWT.error(__FILE__, __LINE__, DWT.ERROR_GRAPHIC_DISPOSED);
		return null;
	}
	BITMAP* bm;
	int depth, width, height;
	switch (type) {
		case DWT.ICON: {
			version(WinCE) {
				return data;
			}
			ICONINFO* info = new ICONINFO();	
			OS.GetIconInfo(handle, info);
			/* Get the basic BITMAP information */
			HBITMAP hBitmap = info.hbmColor;
			if (hBitmap is null) hBitmap = info.hbmMask;
			bm = new BITMAP();
			OS.GetObject(hBitmap, BITMAP.sizeof, bm);
			depth = bm.bmPlanes * bm.bmBitsPixel;
			width = bm.bmWidth;
			if (hBitmap is info.hbmMask) bm.bmHeight /= 2;
			height = bm.bmHeight;
			int numColors = 0;
			if (depth <= 8) numColors = 1 << depth;
			
			/* Create the BITMAPINFO */
			BITMAPINFOHEADER* bmiHeader = new BITMAPINFOHEADER();
			bmiHeader.biSize = BITMAPINFOHEADER.sizeof;
			bmiHeader.biWidth = width;
			bmiHeader.biHeight = -height;
			bmiHeader.biPlanes = 1;
			bmiHeader.biBitCount = cast(WORD)depth;
			bmiHeader.biCompression = OS.BI_RGB;
			byte[] bmi = new byte[BITMAPINFOHEADER.sizeof + numColors * 4];
			OS.MoveMemory(bmi.ptr, bmiHeader, BITMAPINFOHEADER.sizeof);
			
			/* Get the HDC for the device */
			HDC hDC = device.internal_new_GC(null);
	
			/* Create the DC and select the bitmap */
			HDC hBitmapDC = OS.CreateCompatibleDC(hDC);
			HBITMAP hOldBitmap = OS.SelectObject(hBitmapDC, hBitmap);
			/* Select the palette if necessary */
			HPALETTE oldPalette = null;
			if (depth <= 8) {
				HPALETTE hPalette = device.hPalette;
				if (hPalette !is null) {
					oldPalette = OS.SelectPalette(hBitmapDC, hPalette, false);
					OS.RealizePalette(hBitmapDC);
				}
			}
			/* Find the size of the image and allocate data */
			int imageSize;
			/* Call with null lpBits to get the image size */
			OS.GetDIBits(hBitmapDC, hBitmap, 0, height, null, cast(BITMAPINFO*)bmi, OS.DIB_RGB_COLORS);
			OS.MoveMemory(bmiHeader, bmi.ptr, BITMAPINFOHEADER.sizeof);
			imageSize = bmiHeader.biSizeImage;
			
			/* Get the bitmap data */
			byte[] data = new byte[imageSize];
			OS.GetDIBits(hBitmapDC, hBitmap, 0, height, &data, cast(BITMAPINFO*)bmi, OS.DIB_RGB_COLORS);

			/* Calculate the palette */
			PaletteData palette = null;
			if (depth <= 8) {
				DWTRGB[] rgbs = new DWTRGB[numColors];
				int srcIndex = 40;
				for (int i = 0; i < numColors; i++) {
					rgbs[i] = new DWTRGB(bmi[srcIndex + 2] & 0xFF, bmi[srcIndex + 1] & 0xFF, bmi[srcIndex] & 0xFF);
					srcIndex += 4;
				}
				palette = new PaletteData(rgbs);
			} else if (depth == 16) {
				palette = new PaletteData(0x7C00, 0x3E0, 0x1F);
			} else if (depth == 24) {
				palette = new PaletteData(0xFF, 0xFF00, 0xFF0000);
			} else if (depth == 32) {
				palette = new PaletteData(0xFF00, 0xFF0000, 0xFF000000);
			} else {
				DWT.error(__FILE__, __LINE__, DWT.ERROR_UNSUPPORTED_DEPTH);
			}

			/* Do the mask */
			byte [] maskData = null;
			if (info.hbmColor is null) {
				/* Do the bottom half of the mask */
				maskData = new byte[imageSize];
				OS.GetDIBits(hBitmapDC, hBitmap, height, height, maskData.ptr, cast(BITMAPINFO*)bmi, OS.DIB_RGB_COLORS);
			} else {
				/* Do the entire mask */
				/* Create the BITMAPINFO */
				bmiHeader = new BITMAPINFOHEADER();
				bmiHeader.biSize = BITMAPINFOHEADER.sizeof;
				bmiHeader.biWidth = width;
				bmiHeader.biHeight = -height;
				bmiHeader.biPlanes = 1;
				bmiHeader.biBitCount = 1;
				bmiHeader.biCompression = OS.BI_RGB;
				bmi = new byte[BITMAPINFOHEADER.sizeof + 8];
				OS.MoveMemory(bmi.ptr, bmiHeader, BITMAPINFOHEADER.sizeof);
				
				/* First color black, second color white */
				int offset = BITMAPINFOHEADER.sizeof;
				bmi[offset + 4] = bmi[offset + 5] = bmi[offset + 6] = cast(byte)0xFF;
				bmi[offset + 7] = 0;
				OS.SelectObject(hBitmapDC, info.hbmMask);
				/* Call with null lpBits to get the image size */
				OS.GetDIBits(hBitmapDC, info.hbmMask, 0, height, null, cast(BITMAPINFO*)bmi, OS.DIB_RGB_COLORS);
				OS.MoveMemory(bmiHeader, bmi.ptr, BITMAPINFOHEADER.sizeof);
				imageSize = bmiHeader.biSizeImage;
				maskData = new byte[imageSize];
				OS.GetDIBits(hBitmapDC, info.hbmMask, 0, height, maskData.ptr, cast(BITMAPINFO*)bmi, OS.DIB_RGB_COLORS);
				/* Loop to invert the mask */
				for (int i = 0; i < maskData.length; i++) {
					maskData[i] ^= -1;
				}
				/* Make sure mask scanlinePad is 2 */
				int maskPad;
				int bpl = imageSize / height;
				for (maskPad = 1; maskPad < 128; maskPad++) {
					int calcBpl = (((width + 7) / 8) + (maskPad - 1)) / maskPad * maskPad;
					if (calcBpl == bpl) break;
				}
				maskData = ImageData.convertPad(maskData, width, height, 1, maskPad, 2);
			}
			/* Clean up */
			OS.SelectObject(hBitmapDC, hOldBitmap);
			if (oldPalette !is null) {
				OS.SelectPalette(hBitmapDC, oldPalette, false);
				OS.RealizePalette(hBitmapDC);
			}
			OS.DeleteDC(hBitmapDC);
			
			/* Release the HDC for the device */
			device.internal_dispose_GC(hDC, null);
			
			if (info.hbmColor !is null) OS.DeleteObject(info.hbmColor);
			if (info.hbmMask !is null) OS.DeleteObject(info.hbmMask);
			/* Constrct and return the ImageData */
			ImageData imageData = new ImageData(width, height, depth, palette, 4, data);
			imageData.maskData = maskData;
			imageData.maskPad = 2;
			return imageData;
		}
		case DWT.BITMAP: {
			/* Get the basic BITMAP information */
			bm = new BITMAP();
			OS.GetObject(handle, BITMAP.sizeof, bm);
			depth = bm.bmPlanes * bm.bmBitsPixel;
			width = bm.bmWidth;
			height = bm.bmHeight;
			/* Find out whether this is a DIB or a DDB. */
			boolean isDib = (bm.bmBits !is null);
			/* Get the HDC for the device */
			HDC hDC = device.internal_new_GC(null);

			/*
			* Feature in WinCE.  GetDIBits is not available in WinCE.  The
			* workaround is to create a temporary DIB from the DDB and use
			* the bmBits field of DIBSECTION to retrieve the image data.
			*/
			HGDIOBJ handle = this.handle;
			version(WinCE) 
			{
				if (!isDib) {
					boolean mustRestore = false;
					if (memGC !is null && !memGC.isDisposed()) {
						mustRestore = true;
						GCData data = memGC.data;
						if (data.hNullBitmap !is null) {
							OS.SelectObject(memGC.handle, data.hNullBitmap);
							data.hNullBitmap = 0;
						}
					}
					handle = createDIBFromDDB(hDC, this.handle, width, height);
					if (mustRestore) {
						int hOldBitmap = OS.SelectObject(memGC.handle, this.handle);
						memGC.data.hNullBitmap = hOldBitmap;
					}
					isDib = true;
				}
			}
			DIBSECTION* dib = null;
			if (isDib) {
				dib = new DIBSECTION();
				OS.GetObject(handle, DIBSECTION.sizeof, dib);
			}
			/* Calculate number of colors */
			int numColors = 0;
			if (depth <= 8) {
				if (isDib) {
					numColors = dib.biClrUsed;
				} else {
					numColors = 1 << depth;
				}
			}
			/* Create the BITMAPINFO */
			byte[] bmi = null;
			BITMAPINFOHEADER* bmiHeader = null;
			if (!isDib) {
				bmiHeader = new BITMAPINFOHEADER();
				bmiHeader.biSize = BITMAPINFOHEADER.sizeof;
				bmiHeader.biWidth = width;
				bmiHeader.biHeight = -height;
				bmiHeader.biPlanes = 1;
				bmiHeader.biBitCount = cast(WORD)depth;
				bmiHeader.biCompression = OS.BI_RGB;
				bmi = new byte[BITMAPINFOHEADER.sizeof + numColors * 4];
				OS.MoveMemory(bmi.ptr, bmiHeader, BITMAPINFOHEADER.sizeof);
			}
			
			/* Create the DC and select the bitmap */
			HDC hBitmapDC = OS.CreateCompatibleDC(hDC);
			HBITMAP hOldBitmap = OS.SelectObject(hBitmapDC, handle);
			/* Select the palette if necessary */
			HPALETTE oldPalette = null;
			if (!isDib && depth <= 8) {
				HPALETTE hPalette = device.hPalette;
				if (hPalette !is null) {
					oldPalette = OS.SelectPalette(hBitmapDC, hPalette, false);
					OS.RealizePalette(hBitmapDC);
				}
			}
			/* Find the size of the image and allocate data */
			int imageSize;
			if (isDib) {
				imageSize = dib.biSizeImage;
			} else {
				/* Call with null lpBits to get the image size */
				version(WinCE)
				{ 
					DWT.error(__FILE__, __LINE__, DWT.ERROR_NOT_IMPLEMENTED);
				}
				OS.GetDIBits(hBitmapDC, handle, 0, height, null, cast(BITMAPINFO*)bmi, OS.DIB_RGB_COLORS);
				OS.MoveMemory(bmiHeader, bmi.ptr, BITMAPINFOHEADER.sizeof);
				imageSize = bmiHeader.biSizeImage;
			}
			byte[] data = new byte[imageSize];
			/* Get the bitmap data */
			if (isDib) {
				version(WinCE)
				{
					if( this.handle !is handle) {
						/* get image data from the temporary DIB */
						OS.MoveMemory(data, dib.bmBits, imageSize);
					}
				}
				else 
				{
					OS.MoveMemory(data.ptr, bm.bmBits, imageSize);
				}
			} else {
				version(WinCE) 
				{
					DWT.error(__FILE__, __LINE__, DWT.ERROR_NOT_IMPLEMENTED);
				}
				OS.GetDIBits(hBitmapDC, handle, 0, height, data.ptr, cast(BITMAPINFO*)bmi, OS.DIB_RGB_COLORS);
			}
			/* Calculate the palette */
			PaletteData palette = null;
			if (depth <= 8) {
				DWTRGB[] rgbs = new DWTRGB[numColors];
				if (isDib) {
					version(WinCE) 
					{
						/* 
						* Feature on WinCE.  GetDIBColorTable is not supported.
						* The workaround is to set a pixel to the desired
						* palette index and use getPixel to get the corresponding
						* RGB value.
						*/
						int red = 0, green = 0, blue = 0;
						byte[] pBits = new byte[1];
						OS.MoveMemory(pBits, bm.bmBits, 1);
						byte oldValue = pBits[0];			
						int mask = (0xFF << (8 - bm.bmBitsPixel)) & 0x00FF;
						for (int i = 0; i < numColors; i++) {
							pBits[0] = cast(byte)((i << (8 - bm.bmBitsPixel)) | (pBits[0] & ~mask));
							OS.MoveMemory(bm.bmBits, pBits, 1);
							int color = OS.GetPixel(hBitmapDC, 0, 0);
							blue = (color & 0xFF0000) >> 16;
							green = (color & 0xFF00) >> 8;
							red = color & 0xFF;
							rgbs[i] = new DWTRGB(red, green, blue);
						}
		       			pBits[0] = oldValue;
			       		OS.MoveMemory(bm.bmBits, pBits, 1);				
					} // end of versioin(WinCE) 
					else 
					{
						byte[] colors = new byte[numColors * 4];
						OS.GetDIBColorTable(hBitmapDC, 0, numColors, cast(RGBQUAD*)colors);
						int colorIndex = 0;
						for (int i = 0; i < rgbs.length; i++) {
							rgbs[i] = new DWTRGB(colors[colorIndex + 2] & 0xFF, colors[colorIndex + 1] & 0xFF, colors[colorIndex] & 0xFF);
							colorIndex += 4;
						}
					}
				}
				else 
				{
					int srcIndex = BITMAPINFOHEADER.sizeof;
					for (int i = 0; i < numColors; i++) {
						rgbs[i] = new DWTRGB(bmi[srcIndex + 2] & 0xFF, bmi[srcIndex + 1] & 0xFF, bmi[srcIndex] & 0xFF);
						srcIndex += 4;
					}
				}
				palette = new PaletteData(rgbs);
			} else if (depth == 16) {
				palette = new PaletteData(0x7C00, 0x3E0, 0x1F);
			} else if (depth == 24) {
				palette = new PaletteData(0xFF, 0xFF00, 0xFF0000);
			} else if (depth == 32) {
				palette = new PaletteData(0xFF00, 0xFF0000, 0xFF000000);
			} else {
				DWT.error(__FILE__, __LINE__, DWT.ERROR_UNSUPPORTED_DEPTH);
			}
			/* Clean up */
			OS.SelectObject(hBitmapDC, hOldBitmap);
			if (oldPalette !is null) {
				OS.SelectPalette(hBitmapDC, oldPalette, false);
				OS.RealizePalette(hBitmapDC);
			}
			version(WinCE)
			{
				if (handle !is this.handle) {
					/* free temporary DIB */
					OS.DeleteObject (handle);					
				}
			}
			OS.DeleteDC(hBitmapDC);
			
			/* Release the HDC for the device */
			device.internal_dispose_GC(hDC, null);
			
			/* Constrct and return the ImageData */
			ImageData imageData = new ImageData(width, height, depth, palette, 4, data);
			imageData.transparentPixel = this.transparentPixel;
			imageData.alpha = alpha;
			if (alpha == -1 && alphaData !is null) {
				imageData.alphaData = new byte[alphaData.length];
				System.arraycopy(alphaData, 0, imageData.alphaData, 0, alphaData.length);
			}
			return imageData;
		}
		default:
			DWT.error(__FILE__, __LINE__, DWT.ERROR_UNSUPPORTED_FORMAT);
			return null;
	}
	return null;
}

/**
 * Returns an integer hash code for the receiver. Any two 
 * objects which return <code>true</code> when passed to 
 * <code>equals</code> must return the same value for this
 * method.
 *
 * @return the receiver's hash
 *
 * @see #equals
 */
public int hashCode () {
	return cast(int)handle;
}

void init(Device device, int width, int height) {
	if (width <= 0 || height <= 0) {
		DWT.error(__FILE__, __LINE__, DWT.ERROR_INVALID_ARGUMENT);
	}
	this.device = device;
	type = DWT.BITMAP;
	HDC hDC = device.internal_new_GC(null);
	handle = OS.CreateCompatibleBitmap(hDC, width, height);
	if (handle !is null) {
		HDC memDC = OS.CreateCompatibleDC(hDC);
		HBITMAP hOldBitmap = OS.SelectObject(memDC, handle);
		OS.PatBlt(memDC, 0, 0, width, height, OS.PATCOPY);
		OS.SelectObject(memDC, hOldBitmap);
		OS.DeleteDC(memDC);
	}
	device.internal_dispose_GC(hDC, null);
	if (handle is null) {
		DWT.error(__FILE__, __LINE__, DWT.ERROR_NO_HANDLES);
	}
}

/**
 * Feature in WinCE.  GetIconInfo is not available in WinCE.
 * The workaround is to cache the object ImageData for images
 * of type DWT.ICON. The bitmaps hbmMask and hbmColor can then
 * be reconstructed by using our version of getIconInfo.
 * This function takes an ICONINFO object and sets the fields
 * hbmMask and hbmColor with the corresponding bitmaps it has
 * created.
 * Note.  These bitmaps must be freed - as they would have to be
 * if the regular GetIconInfo had been used.
 */
static void GetIconInfo(Image image, ICONINFO* info) {
	HGDIOBJ[] result = init(image.device, null, image.data);
	info.hbmColor = result[0];
	info.hbmMask = result[1];
}

static HGDIOBJ[] init(Device device, Image image, ImageData i) {
	if (image !is null) image.device = device;
	
	/*
	 * BUG in Windows 98:
	 * A monochrome DIBSection will display as solid black
	 * on Windows 98 machines, even though it contains the
	 * correct data. The fix is to convert 1-bit ImageData
	 * into 4-bit ImageData before creating the image.
	 */
	/* Windows does not support 2-bit images. Convert to 4-bit image. */
	if ((i.depth == 1 && i.getTransparencyType() != DWT.TRANSPARENCY_MASK) || i.depth == 2) {
		ImageData img = new ImageData(i.width, i.height, 4, i.palette);
		ImageData.blit(ImageData.BLIT_SRC, 
			i.data, i.depth, i.bytesPerLine, i.getByteOrder(), 0, 0, i.width, i.height, null, null, null,
			ImageData.ALPHA_OPAQUE, null, 0, 0, 0,
			img.data, img.depth, img.bytesPerLine, i.getByteOrder(), 0, 0, img.width, img.height, null, null, null, 
			false, false);
		img.transparentPixel = i.transparentPixel;
		img.maskPad = i.maskPad;
		img.maskData = i.maskData;
		img.alpha = i.alpha;
		img.alphaData = i.alphaData;
		i = img;
	}
	/*
	 * Windows supports 16-bit mask of (0x7C00, 0x3E0, 0x1F),
	 * 24-bit mask of (0xFF0000, 0xFF00, 0xFF) and 32-bit mask
	 * (0x00FF0000, 0x0000FF00, 0x000000FF) as documented in 
	 * MSDN BITMAPINFOHEADER.  Make sure the image is 
	 * Windows-supported.
	 */
	/*
	* Note on WinCE.  CreateDIBSection requires the biCompression
	* field of the BITMAPINFOHEADER to be set to BI_BITFIELDS for
	* 16 and 32 bit direct images (see MSDN for CreateDIBSection).
	* In this case, the color mask can be set to any value.  For
	* consistency, it is set to the same mask used by non WinCE
	* platforms in BI_RGB mode.
	*/
	if (i.palette.isDirect) {
		PaletteData palette = i.palette;
		int redMask = palette.redMask;
		int greenMask = palette.greenMask;
		int blueMask = palette.blueMask;
		int newDepth = i.depth;
		int newOrder = ImageData.MSB_FIRST;
		PaletteData newPalette = null;

		switch (i.depth) {
			case 8:
				newDepth = 16;
				newOrder = ImageData.LSB_FIRST;
				newPalette = new PaletteData(0x7C00, 0x3E0, 0x1F);
				break;
			case 16:
				newOrder = ImageData.LSB_FIRST;
				if (!(redMask == 0x7C00 && greenMask == 0x3E0 && blueMask == 0x1F)) {
					newPalette = new PaletteData(0x7C00, 0x3E0, 0x1F);
				}
				break;
			case 24: 
				if (!(redMask == 0xFF && greenMask == 0xFF00 && blueMask == 0xFF0000)) {
					newPalette = new PaletteData(0xFF, 0xFF00, 0xFF0000);
				}
				break;
			case 32: 
				if (!(redMask == 0xFF00 && greenMask == 0xFF0000 && blueMask == 0xFF000000)) {
					newPalette = new PaletteData(0xFF00, 0xFF0000, 0xFF000000);
				}
				break;
			default:
				DWT.error(__FILE__, __LINE__, DWT.ERROR_UNSUPPORTED_DEPTH);
		}
		if (newPalette !is null) {
			ImageData img = new ImageData(i.width, i.height, newDepth, newPalette);
			ImageData.blit(ImageData.BLIT_SRC, 
					i.data, i.depth, i.bytesPerLine, i.getByteOrder(), 0, 0, i.width, i.height, redMask, greenMask, blueMask,
					ImageData.ALPHA_OPAQUE, null, 0, 0, 0,
					img.data, img.depth, img.bytesPerLine, newOrder, 0, 0, img.width, img.height, newPalette.redMask, newPalette.greenMask, newPalette.blueMask,
					false, false);
			if (i.transparentPixel != -1) {
				img.transparentPixel = newPalette.getPixel(palette.getRGB(i.transparentPixel));
			}
			img.maskPad = i.maskPad;
			img.maskData = i.maskData;
			img.alpha = i.alpha;
			img.alphaData = i.alphaData;
			i = img;
		}
	}
	/* Constrct bitmap info header by hand */
	DWTRGB[] rgbs = i.palette.getRGBs();
	boolean useBitfields = OS.IsWinCE && (i.depth == 16 || i.depth == 32);
	BITMAPINFOHEADER* bmiHeader = new BITMAPINFOHEADER();
	bmiHeader.biSize = BITMAPINFOHEADER.sizeof;
	bmiHeader.biWidth = i.width;
	bmiHeader.biHeight = -i.height;
	bmiHeader.biPlanes = 1;
	bmiHeader.biBitCount = cast(WORD)i.depth;
	if (useBitfields) bmiHeader.biCompression = OS.BI_BITFIELDS;
	else bmiHeader.biCompression = OS.BI_RGB;
	bmiHeader.biClrUsed = rgbs is null ? 0 : rgbs.length;
	byte[] bmi;
	if (i.palette.isDirect)
		bmi = new byte[BITMAPINFOHEADER.sizeof + (useBitfields ? 12 : 0)];
	else
		bmi = new byte[BITMAPINFOHEADER.sizeof + rgbs.length * 4];
	OS.MoveMemory(bmi.ptr, bmiHeader, BITMAPINFOHEADER.sizeof);
	/* Set the rgb colors into the bitmap info */
	int offset = BITMAPINFOHEADER.sizeof;
	if (i.palette.isDirect) {
		if (useBitfields) {
			PaletteData palette = i.palette;
			int redMask = palette.redMask;
			int greenMask = palette.greenMask;
			int blueMask = palette.blueMask;
			/*
			 * The color masks must be written based on the
			 * endianness of the ImageData.
			 */
			if (i.getByteOrder() == ImageData.LSB_FIRST) {
				bmi[offset] = cast(byte)((redMask & 0xFF) >> 0);
				bmi[offset + 1] = cast(byte)((redMask & 0xFF00) >> 8);
				bmi[offset + 2] = cast(byte)((redMask & 0xFF0000) >> 16);
				bmi[offset + 3] = cast(byte)((redMask & 0xFF000000) >> 24);
				bmi[offset + 4] = cast(byte)((greenMask & 0xFF) >> 0);
				bmi[offset + 5] = cast(byte)((greenMask & 0xFF00) >> 8);
				bmi[offset + 6] = cast(byte)((greenMask & 0xFF0000) >> 16);
				bmi[offset + 7] = cast(byte)((greenMask & 0xFF000000) >> 24);
				bmi[offset + 8] = cast(byte)((blueMask & 0xFF) >> 0);
				bmi[offset + 9] = cast(byte)((blueMask & 0xFF00) >> 8);
				bmi[offset + 10] = cast(byte)((blueMask & 0xFF0000) >> 16);
				bmi[offset + 11] = cast(byte)((blueMask & 0xFF000000) >> 24);
			} else {
				bmi[offset] = cast(byte)((redMask & 0xFF000000) >> 24);
				bmi[offset + 1] = cast(byte)((redMask & 0xFF0000) >> 16);
				bmi[offset + 2] = cast(byte)((redMask & 0xFF00) >> 8);
				bmi[offset + 3] = cast(byte)((redMask & 0xFF) >> 0);
				bmi[offset + 4] = cast(byte)((greenMask & 0xFF000000) >> 24);
				bmi[offset + 5] = cast(byte)((greenMask & 0xFF0000) >> 16);
				bmi[offset + 6] = cast(byte)((greenMask & 0xFF00) >> 8);
				bmi[offset + 7] = cast(byte)((greenMask & 0xFF) >> 0);
				bmi[offset + 8] = cast(byte)((blueMask & 0xFF000000) >> 24);
				bmi[offset + 9] = cast(byte)((blueMask & 0xFF0000) >> 16);
				bmi[offset + 10] = cast(byte)((blueMask & 0xFF00) >> 8);
				bmi[offset + 11] = cast(byte)((blueMask & 0xFF) >> 0);
			}
		}
	} else {
		for (int j = 0; j < rgbs.length; j++) {
			bmi[offset] = cast(byte)rgbs[j].blue;
			bmi[offset + 1] = cast(byte)rgbs[j].green;
			bmi[offset + 2] = cast(byte)rgbs[j].red;
			bmi[offset + 3] = 0;
			offset += 4;
		}
	}
	int[] pBits = new int[1];
	HBITMAP hDib = OS.CreateDIBSection(null, cast(BITMAPINFO*)bmi, cast(uint)OS.DIB_RGB_COLORS, cast(void**)pBits.ptr, null, 0);
	if (hDib is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NO_HANDLES);
	/* In case of a scanline pad other than 4, do the work to convert it */
	byte[] data = i.data;
	if (i.scanlinePad != 4 && (i.bytesPerLine % 4 != 0)) {
		data = ImageData.convertPad(data, i.width, i.height, i.depth, i.scanlinePad, 4);
	}
	OS.MoveMemory(pBits[0], data.ptr, data.length);
	
	HBITMAP[] result = null;
	if (i.getTransparencyType() == DWT.TRANSPARENCY_MASK) {
		/* Get the HDC for the device */
		HDC hDC = device.internal_new_GC(null);
			
		/* Create the color bitmap */
		HDC hdcSrc = OS.CreateCompatibleDC(hDC);
		OS.SelectObject(hdcSrc, hDib);
		HBITMAP hBitmap = OS.CreateCompatibleBitmap(hDC, i.width, i.height);
		if (hBitmap is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NO_HANDLES);
		HDC hdcDest = OS.CreateCompatibleDC(hDC);
		OS.SelectObject(hdcDest, hBitmap);
		OS.BitBlt(hdcDest, 0, 0, i.width, i.height, hdcSrc, 0, 0, OS.SRCCOPY);
		
		/* Release the HDC for the device */	
		device.internal_dispose_GC(hDC, null);
			
		/* Create the mask. Windows requires icon masks to have a scanline pad of 2. */
		byte[] maskData = ImageData.convertPad(i.maskData, i.width, i.height, 1, i.maskPad, 2);
		HBITMAP hMask = OS.CreateBitmap(i.width, i.height, 1, 1, maskData.ptr);
		if (hMask is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NO_HANDLES);	
		OS.SelectObject(hdcSrc, hMask);
		OS.PatBlt(hdcSrc, 0, 0, i.width, i.height, OS.DSTINVERT);
		OS.DeleteDC(hdcSrc);
		OS.DeleteDC(hdcDest);
		OS.DeleteObject(hDib);
		
		if (image is null) {
			HBITMAP[] intArr;
			intArr ~= hBitmap;
			intArr ~= hMask;
			result = intArr; 
		} else {
			/* Create the icon */
			ICONINFO info;
			info.fIcon = true;
			info.hbmColor = hBitmap;
			info.hbmMask = hMask;
			HICON hIcon= OS.CreateIconIndirect(&info);
			if (hIcon is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NO_HANDLES);
			OS.DeleteObject(hBitmap);
			OS.DeleteObject(hMask);
			image.handle = hIcon;
			image.type = DWT.ICON;
			version(WinCE) { image.data = i; }
		}
	} else {
		if (image is null) {
			HBITMAP[] intArr;
			intArr ~= hDib;
			result = intArr;
		} else {
			image.handle = hDib;
			image.type = DWT.BITMAP;
			image.transparentPixel = i.transparentPixel;
			if (image.transparentPixel == -1) {
				image.alpha = i.alpha;
				if (i.alpha == -1 && i.alphaData !is null) {
					int len = i.alphaData.length;
					image.alphaData = new byte[len];
					System.arraycopy(i.alphaData, 0, image.alphaData, 0, len);
				}
			}
		}
	}
	return result;
}

static HGDIOBJ[] init4(Device device, Image image, ImageData source, ImageData mask) {
	/* Create a temporary image and locate the black pixel */
	ImageData imageData;
	int blackIndex = 0;
	if (source.palette.isDirect) {
		imageData = new ImageData(source.width, source.height, source.depth, source.palette);
	} else {
		DWTRGB black = new DWTRGB(0, 0, 0);
		DWTRGB[] rgbs = source.getRGBs();
		if (source.transparentPixel != -1) {
			/*
			 * The source had transparency, so we can use the transparent pixel
			 * for black.
			 */
			DWTRGB[] newRGBs = new DWTRGB[rgbs.length];
			System.arraycopy(rgbs, 0, newRGBs, 0, rgbs.length);
			if (source.transparentPixel >= newRGBs.length) {
				/* Grow the palette with black */
				rgbs = new DWTRGB[source.transparentPixel + 1];
				System.arraycopy(newRGBs, 0, rgbs, 0, newRGBs.length);
				for (int i = newRGBs.length; i <= source.transparentPixel; i++) {
					rgbs[i] = new DWTRGB(0, 0, 0);
				}
			} else {
				newRGBs[source.transparentPixel] = black;
				rgbs = newRGBs;
			}
			blackIndex = source.transparentPixel;
			imageData = new ImageData(source.width, source.height, source.depth, new PaletteData(rgbs));
		} else {
			while (blackIndex < rgbs.length) {
				if (rgbs[blackIndex].equals(black)) break;
				blackIndex++;
			}
			if (blackIndex == rgbs.length) {
				/*
				 * We didn't find black in the palette, and there is no transparent
				 * pixel we can use.
				 */
				if ((1 << source.depth) > rgbs.length) {
					/* We can grow the palette and add black */
					DWTRGB[] newRGBs = new DWTRGB[rgbs.length + 1];
					System.arraycopy(rgbs, 0, newRGBs, 0, rgbs.length);
					newRGBs[rgbs.length] = black;
					rgbs = newRGBs;
				} else {
					/* No room to grow the palette */
					blackIndex = -1;
				}
			}
			imageData = new ImageData(source.width, source.height, source.depth, new PaletteData(rgbs));
		}
	}
	if (blackIndex == -1) {
		/* There was no black in the palette, so just copy the data over */
		System.arraycopy(source.data, 0, imageData.data, 0, imageData.data.length);
	} else {
		/* Modify the source image to contain black wherever the mask is 0 */
		int[] imagePixels = new int[imageData.width];
		int[] maskPixels = new int[mask.width];
		for (int y = 0; y < imageData.height; y++) {
			source.getPixels(0, y, imageData.width, imagePixels, 0);
			mask.getPixels(0, y, mask.width, maskPixels, 0);
			for (int i = 0; i < imagePixels.length; i++) {
				if (maskPixels[i] == 0) imagePixels[i] = blackIndex;
			}
			imageData.setPixels(0, y, source.width, imagePixels, 0);
		}
	}
	imageData.maskPad = mask.scanlinePad;
	imageData.maskData = mask.data;	
	return init(device, image, imageData);
}
void init(Device device, ImageData i) {
	if (i is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NULL_ARGUMENT);
	init(device, this, i);
}

/**	 
 * Invokes platform specific functionality to allocate a new GC handle.
 * <p>
 * <b>IMPORTANT:</b> This method is <em>not</em> part of the public
 * API for <code>Image</code>. It is marked public only so that it
 * can be shared within the packages provided by DWT. It is not
 * available on all platforms, and should never be called from
 * application code.
 * </p>
 *
 * @param data the platform specific GC data 
 * @return the platform specific GC handle
 */
public HDC internal_new_GC (GCData data) {
	if (handle is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_GRAPHIC_DISPOSED);
	/*
	* Create a new GC that can draw into the image.
	* Only supported for bitmaps.
	*/
	if (type != DWT.BITMAP || memGC !is null) {
		DWT.error(__FILE__, __LINE__, DWT.ERROR_INVALID_ARGUMENT);
	}
	
	/* Create a compatible HDC for the device */
	HDC hDC = device.internal_new_GC(null);
	HDC imageDC = OS.CreateCompatibleDC(hDC);
	device.internal_dispose_GC(hDC, null);
	if (imageDC is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NO_HANDLES);

	if (data !is null) {
		/* Set the GCData fields */
		int mask = DWT.LEFT_TO_RIGHT | DWT.RIGHT_TO_LEFT;
		if ((data.style & mask) != 0) {
			data.layout = (data.style & DWT.RIGHT_TO_LEFT) != 0 ? OS.LAYOUT_RTL : 0;
		} else {
			data.style |= DWT.LEFT_TO_RIGHT;
		}
		data.device = device;
		data.image = this;
		data.hFont = device.systemFont;
	}
	return imageDC;
}

/**	 
 * Invokes platform specific functionality to dispose a GC handle.
 * <p>
 * <b>IMPORTANT:</b> This method is <em>not</em> part of the public
 * API for <code>Image</code>. It is marked public only so that it
 * can be shared within the packages provided by DWT. It is not
 * available on all platforms, and should never be called from
 * application code.
 * </p>
 *
 * @param hDC the platform specific GC handle
 * @param data the platform specific GC data 
 */
public void internal_dispose_GC (HDC hDC, GCData data) {
	OS.DeleteDC(hDC);
}

/**
 * Returns <code>true</code> if the image has been disposed,
 * and <code>false</code> otherwise.
 * <p>
 * This method gets the dispose state for the image.
 * When an image has been disposed, it is an error to
 * invoke any other method using the image.
 *
 * @return <code>true</code> when the image is disposed and <code>false</code> otherwise
 */
public boolean isDisposed() {
	return handle is null;
}

/**
 * Sets the color to which to map the transparent pixel.
 * <p>
 * There are certain uses of <code>Images</code> that do not support
 * transparency (for example, setting an image into a button or label).
 * In these cases, it may be desired to simulate transparency by using
 * the background color of the widget to paint the transparent pixels
 * of the image. This method specifies the color that will be used in
 * these cases. For example:
 * <pre>
 *    Button b = new Button();
 *    image.setBackground(b.getBackground());
 *    b.setImage(image);
 * </pre>
 * </p><p>
 * The image may be modified by this operation (in effect, the
 * transparent regions may be filled with the supplied color).  Hence
 * this operation is not reversible and it is not legal to call
 * this function twice or with a null argument.
 * </p><p>
 * This method has no effect if the receiver does not have a transparent
 * pixel value.
 * </p>
 *
 * @param color the color to use when a transparent pixel is specified
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if the color is null</li>
 *    <li>ERROR_INVALID_ARGUMENT - if the color has been disposed</li>
 * </ul>
 * @exception SWTException <ul>
 *    <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed</li>
 * </ul>
 */
public void setBackground(Color color) {
	/*
	* Note.  Not implemented on WinCE.
	*/
	version(WinCE) { return; }
	if (isDisposed()) DWT.error(__FILE__, __LINE__, DWT.ERROR_GRAPHIC_DISPOSED);
	if (color is null) DWT.error(__FILE__, __LINE__, DWT.ERROR_NULL_ARGUMENT);
	if (color.isDisposed()) DWT.error(__FILE__, __LINE__, DWT.ERROR_INVALID_ARGUMENT);
	if (transparentPixel == -1) return;

	/* Get the HDC for the device */
	HDC hDC = device.internal_new_GC(null);
	
	/* Change the background color in the image */
	BITMAP* bm = new BITMAP();		
	OS.GetObject(handle, BITMAP.sizeof, bm);
	HDC hdcMem = OS.CreateCompatibleDC(hDC);
	OS.SelectObject(hdcMem, handle);
	int maxColors = 1 << bm.bmBitsPixel;
	byte[] colors = new byte[maxColors * 4];
	version(WinCE) { DWT.error(__FILE__, __LINE__, DWT.ERROR_NOT_IMPLEMENTED); }
	int numColors = OS.GetDIBColorTable(hdcMem, 0, maxColors, cast(RGBQUAD*)colors);
	int offset = transparentPixel * 4;
	colors[offset] = cast(byte)color.getBlue();
	colors[offset + 1] = cast(byte)color.getGreen();
	colors[offset + 2] = cast(byte)color.getRed();
	version(WinCE) { DWT.error(__FILE__, __LINE__, DWT.ERROR_NOT_IMPLEMENTED); }
	OS.SetDIBColorTable(hdcMem, 0, numColors, cast(RGBQUAD*)colors);
	OS.DeleteDC(hdcMem);
	
	/* Release the HDC for the device */	
	device.internal_dispose_GC(hDC, null);
}

/**
 * Returns a string containing a concise, human-readable
 * description of the receiver.
 *
 * @return a string representation of the receiver
 */
public char[] toString() {
	
	if (isDisposed()) return ("Image {*DISPOSED*}");
	char[] s = "Image {" ~ Int.toString(cast(uint)handle) ~ "}";
	return s;
}

/**	 
 * Invokes platform specific functionality to allocate a new image.
 * <p>
 * <b>IMPORTANT:</b> This method is <em>not</em> part of the public
 * API for <code>Image</code>. It is marked public only so that it
 * can be shared within the packages provided by DWT. It is not
 * available on all platforms, and should never be called from
 * application code.
 * </p>
 *
 * @param device the device on which to allocate the color
 * @param type the type of the image (<code>DWT.BITMAP</code> or <code>DWT.ICON</code>)
 * @param handle the OS handle for the image
 * @return a new image object containing the specified device, type and handle
 */
public static Image win32_new(Device device, int type, HGDIOBJ handle) {
	if (device is null) device = Device.getDevice();
	Image image = new Image();
	image.type = type;
	image.handle = handle;
	image.device = device;
	return image;
}

}
